home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2005 June (DVD) / DPPRO0605DVD.iso / Install / program files / Borland / BDS / 3.0 / Demos / Delphi.Net / VCL / Lexer / mwDelphiDirectiveParser.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  2004-10-22  |  69.7 KB  |  2,584 lines

  1. {-----------------------------------------------------------------------------
  2. This Software is placed into Publlic Domain and distributed on an "AS IS" basis,
  3. WITHOUT WARRANTY OF ANY KIND, either express or implied.
  4. The Initial Developer is Martin Waldenburg
  5. (Martin.Waldenburg@T-Online.de).
  6. Contributor: James Jacobson
  7. -----------------------------------------------------------------------------}
  8. unit mwDelphiDirectiveParser;
  9.  
  10. interface
  11.  
  12. uses
  13.   SysUtils, mwDelphiLanguageElements,
  14.   mwD4NLexer;
  15.  
  16. type
  17.   TmwDelphiDirectiveParser = class(TmwD4NLexer)
  18.   protected
  19.     function CheckCondition: Boolean;
  20.     function CheckDeclared: Boolean;
  21.     function CheckDefined: Boolean;
  22.     function CheckDirectiveExpression: Boolean;
  23.     function CheckTypeOfConstant: Integer;
  24.     function CheckTypeOfRelation: Integer;
  25.     procedure CheckCommaOrEnd;
  26.     function CheckIfDirective: Boolean;
  27.     procedure DirectiveHandler;
  28.     function EvaluateDirectiveExpression(ConstTypeOne: Integer; ConstOne: AnsiString;
  29.       RelationType, ConstTypeTwo: Integer; ConstTwo: AnsiString): Boolean; virtual;
  30.     procedure FindDirectiveEnd;
  31.     procedure IncludeFile(FileName: AnsiString);
  32.     procedure LinkObjectFile(FileName: AnsiString);
  33.     procedure MainDirectiveHandler;
  34.     procedure leAHandler;
  35.     procedure leBHandler;
  36.     procedure leCHandler;
  37.     procedure leDHandler;
  38.     procedure leEHandler;
  39.     procedure leGHandler;
  40.     procedure leHHandler;
  41.     procedure leIHandler;
  42.     procedure leJHandler;
  43.     procedure leLHandler;
  44.     procedure leMHandler;
  45.     procedure leOHandler;
  46.     procedure lePHandler;
  47.     procedure leQHandler;
  48.     procedure leRHandler;
  49.     procedure leSHandler;
  50.     procedure leTHandler;
  51.     procedure leUHandler;
  52.     procedure leVHandler;
  53.     procedure leWHandler;
  54.     procedure leXHandler;
  55.     procedure leYHandler;
  56.     procedure leZHandler;
  57.     procedure leYDHandler;
  58.     procedure leIfDirectiveHandler;
  59.     procedure leIfDefHandler;
  60.     procedure leEndIfHandler;
  61.     procedure leIfEndHandler;
  62.     procedure leElseDirectiveHandler;
  63.     procedure leDefineHandler;
  64.     procedure leAlignHandler;
  65.     procedure leIfNDefHandler;
  66.     procedure leLinkHandler;
  67.     procedure leUnDefHandler;
  68.     procedure leElseIfHandler;
  69.     procedure leImageBaseHandler;
  70.     procedure leIfOptHandler;
  71.     procedure leSoNameHandler;
  72.     procedure leIncludeHandler;
  73.     procedure leHintsHandler;
  74.     procedure leNoDefineHandler;
  75.     procedure leIOChecksHandler;
  76.     procedure leDebugInfoHandler;
  77.     procedure leBoolevalHandler;
  78.     procedure leHPPEmitHandler;
  79.     procedure leRangeChecksHandler;
  80.     procedure leNoIncludeHandler;
  81.     procedure leApptypeHandler;
  82.     procedure leSafeDivideHandler;
  83.     procedure leStackChecksHandler;
  84.     procedure leResourceHandler;
  85.     procedure leWarnHandler;
  86.     procedure leWarningsHandler;
  87.     procedure leTypeInfoHandler;
  88.     procedure leSoPrefixHandler;
  89.     procedure leStackFramesHandler;
  90.     procedure leRunOnlyHandler;
  91.     procedure leSoSuffixHandler;
  92.     procedure leReferenceInfoHandler;
  93.     procedure leDesignOnlyHandler;
  94.     procedure leExtensionHandler;
  95.     procedure leImportedDataHandler;
  96.     procedure leDescriptionHandler;
  97.     procedure leSoVersionHandler;
  98.     procedure leAssertionsHandler;
  99.     procedure leImplicitBuildHandler;
  100.     procedure leTypedAddressHandler;
  101.     procedure leLocalSymbolsHandler;
  102.     procedure leMinEnumSizeHandler;
  103.     procedure leWeakPackageUnitHandler;
  104.     procedure leDefinitionInfoHandler;
  105.     procedure leMinStackSizeHandler;
  106.     procedure leObjExportAllHandler;
  107.     procedure leMaxStackSizeHandler;
  108.     procedure leLongStringsHandler;
  109.     procedure leDenyPackageUnitHandler;
  110.     procedure leExternalSymHandler;
  111.     procedure leOpenStringsHandler;
  112.     procedure leOverFlowChecksHandler;
  113.     procedure leWriteableConstHandler;
  114.     procedure leOptimizationHandler;
  115.     procedure leVarStringChecksHandler;
  116.     procedure leExtendedSyntaxHandler;
  117.     procedure leRealCompatibilityHandler;
  118.     procedure leResourceReserveHandler;
  119.     procedure leRegionHandler;
  120.     procedure leEndRegionHandler;
  121.     procedure SkipUntilElseOrEndIf;
  122.     procedure SkipUntilElseIfOrIfEnd;
  123.     procedure SkipUntilEndIf;
  124.     procedure SkipUntilIfEnd;
  125.   public
  126.     procedure NextToken; override;
  127.     procedure Parse; virtual;
  128.   end;
  129.  
  130. implementation
  131.  
  132. procedure TmwDelphiDirectiveParser.CheckCommaOrEnd;
  133. var
  134.   TempRange: TmwDelphiRange;
  135. begin
  136.   TempRange := Range;
  137.   Next;
  138.   case Id of
  139.     leComma:
  140.       begin
  141.         Next;
  142.         DirectiveHandler;
  143.       end;
  144.     leCurlyClose:
  145.       case TempRange of
  146.         drBorlandDirective: Id := leBorlandDirective;
  147.       else Id := leUnknownDirective;
  148.       end;
  149.     leEndOfAnsiComment:
  150.       case TempRange of
  151.         drAnsiDirective: Id := leAnsiDirective;
  152.       else Id := leUnknownDirective;
  153.       end;
  154.   else FindDirectiveEnd;
  155.   end;
  156. end;
  157.  
  158. function TmwDelphiDirectiveParser.CheckDeclared: Boolean;
  159. begin
  160.   Result := False;
  161.   NextNoSpace;
  162.   if Id = leRoundOpen then
  163.     NextNoSpace;
  164.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  165.     True:
  166.       begin
  167.         Result := fDeclaredList.IndexOf(Token) > -1;
  168.       end;
  169.   end;
  170.   NextNoSpace;
  171.   if Id = leRoundClose then
  172.     NextNoSpace;
  173. end;
  174.  
  175. function TmwDelphiDirectiveParser.CheckDefined: Boolean;
  176. begin
  177.   Result := False;
  178.   NextNoSpace;
  179.   if Id = leRoundOpen then
  180.     NextNoSpace;
  181.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  182.     True:
  183.       begin
  184.         Result := fDefinedList.IndexOf(Token) > -1;
  185.       end;
  186.   end;
  187.   NextNoSpace;
  188.   if Id = leRoundClose then
  189.     NextNoSpace;
  190. end;
  191.  
  192. function TmwDelphiDirectiveParser.CheckTypeOfConstant: Integer;
  193. begin
  194.   Result := leUnknown;
  195.   case Id of
  196.     leNumber, leFloat, leStringConstant:
  197.       Result := Id;
  198.   else
  199.     if (Id = leIdentifier) or (ExId = leIdentifier) then Result := leIdentifier;
  200.   end;
  201. end;
  202.  
  203. function TmwDelphiDirectiveParser.CheckTypeOfRelation: Integer;
  204. begin
  205.   Result := leUnknown;
  206.   case Id of
  207.     leEqual, leNotEqual, leLess, leGreater, leLessOrEqual, leGreaterOrEqual:
  208.       Result := ID;
  209.   end;
  210. end;
  211.  
  212. function TmwDelphiDirectiveParser.CheckDirectiveExpression: Boolean;
  213. var
  214.   ConstOne, ConstTwo: string;
  215.   ConstTypeOne, RelationType, ConstTypeTwo: Integer;
  216. begin
  217.   Result := False;
  218.   case Id of
  219.     leRoundOpen:
  220.       begin
  221.         NextNoSpace;
  222.         Result := CheckCondition;
  223.         if id = leRoundClose then
  224.           NextNoSpace;
  225.         case Id of
  226.           leAnd:
  227.             begin
  228.               NextNoSpace;
  229.               Result := Result and CheckCondition;
  230.             end;
  231.           leOr:
  232.             begin
  233.               NextNoSpace;
  234.               Result := Result or CheckCondition;
  235.             end;
  236.         end;
  237.       end;
  238.   else
  239.     begin
  240.       ConstTypeOne := CheckTypeOfConstant;
  241.       ConstOne := Token;
  242.       if ConstTypeOne <> leUnknown then
  243.         NextNoSpace;
  244.       RelationType := CheckTypeOfRelation;
  245.       if RelationType <> leUnknown then
  246.         NextNoSpace;
  247.       ConstTypeTwo := CheckTypeOfConstant;
  248.       ConstTwo := Token;
  249.       if (ConstTypeOne <> leUnknown)
  250.         and (ConstTypeTwo <> leUnknown)
  251.         and (RelationType <> leUnknown) then
  252.       begin
  253.         Result := EvaluateDirectiveExpression(ConstTypeOne, ConstOne, RelationType,
  254.           ConstTypeTwo, ConstTwo);
  255.         NextNoSpace;
  256.         case Id of
  257.           leAnd:
  258.             begin
  259.               NextNoSpace;
  260.               Result := Result and CheckCondition;
  261.             end;
  262.           leOr:
  263.             begin
  264.               NextNoSpace;
  265.               Result := Result or CheckCondition;
  266.             end;
  267.         end;
  268.       end;
  269.     end;
  270.   end;
  271. end;
  272.  
  273. function TmwDelphiDirectiveParser.CheckCondition: Boolean;
  274. begin
  275.   Result := False;
  276.   case Id of
  277.     leAtEnd: ;
  278.     leDeclared:
  279.       begin
  280.         Result := CheckDeclared;
  281.       end;
  282.     leDefined:
  283.       begin
  284.         Result := CheckDefined;
  285.       end;
  286.     leNumber, leFloat, leStringConstant:
  287.       begin
  288.         Result := CheckDirectiveExpression;
  289.       end;
  290.     leRoundOpen: Result := CheckDirectiveExpression;
  291.   else
  292.     begin
  293.       case (Id = leIdentifier) or (ExId = leIdentifier) of
  294.         True: Result := CheckDirectiveExpression;
  295.       end;
  296.     end;
  297.   end;
  298. end;
  299.  
  300. function TmwDelphiDirectiveParser.CheckIfDirective: Boolean;
  301. begin
  302.   Result := CheckCondition;
  303. end;
  304.  
  305. procedure TmwDelphiDirectiveParser.DirectiveHandler;
  306. begin
  307.   case Id of
  308.     leA: leAHandler;
  309.     leB: leBHandler;
  310.     leC: leCHandler;
  311.     leD: leDHandler;
  312.     leE: leEHandler;
  313.     leG: leGHandler;
  314.     leH: leHHandler;
  315.     leI: leIHandler;
  316.     leJ: leJHandler;
  317.     leL: leLHandler;
  318.     leM: leMHandler;
  319.     leO: leOHandler;
  320.     leP: lePHandler;
  321.     leQ: leQHandler;
  322.     leR: leRHandler;
  323.     leS: leSHandler;
  324.     leT: leTHandler;
  325.     leU: leUHandler;
  326.     leV: leVHandler;
  327.     leW: leWHandler;
  328.     leX: leXHandler;
  329.     leY: leYHandler;
  330.     leZ: leZHandler;
  331.     leYD: leYDHandler;
  332.     leDefine: leDefineHandler;
  333.     leAlign: leAlignHandler;
  334.     leIfNDef: leIfNDefHandler;
  335.     leLink: leLinkHandler;
  336.     leUnDef: leUnDefHandler;
  337.     leImageBase: leImageBaseHandler;
  338.     leSoName: leSoNameHandler;
  339.     leInclude: leIncludeHandler;
  340.     leHints: leHintsHandler;
  341.     leNoDefine: leNoDefineHandler;
  342.     leIOChecks: leIOChecksHandler;
  343.     leDebugInfo: leDebugInfoHandler;
  344.     leBooleval: leBoolevalHandler;
  345.     leHPPEmit: leHPPEmitHandler;
  346.     leRangeChecks: leRangeChecksHandler;
  347.     leNoInclude: leNoIncludeHandler;
  348.     leApptype: leApptypeHandler;
  349.     leSafeDivide: leSafeDivideHandler;
  350.     leResource: leResourceHandler;
  351.     leWarn: leWarnHandler;
  352.     leWarnings: leWarningsHandler;
  353.     leTypeInfo: leTypeInfoHandler;
  354.     leSoPrefix: leSoPrefixHandler;
  355.     leStackFrames: leStackFramesHandler;
  356.     leRunOnly: leRunOnlyHandler;
  357.     leSoSuffix: leSoSuffixHandler;
  358.     leReferenceInfo: leReferenceInfoHandler;
  359.     leDesignOnly: leDesignOnlyHandler;
  360.     leExtension: leExtensionHandler;
  361.     leImportedData: leImportedDataHandler;
  362.     leDescription: leDescriptionHandler;
  363.     leSoVersion: leSoVersionHandler;
  364.     leAssertions: leAssertionsHandler;
  365.     leImplicitBuild: leImplicitBuildHandler;
  366.     leTypedAddress: leTypedAddressHandler;
  367.     leLocalSymbols: leLocalSymbolsHandler;
  368.     leMinEnumSize: leMinEnumSizeHandler;
  369.     leWeakPackageUnit: leWeakPackageUnitHandler;
  370.     leDefinitionInfo: leDefinitionInfoHandler;
  371.     leMinStackSize: leMinStackSizeHandler;
  372.     leObjExportAll: leObjExportAllHandler;
  373.     leMaxStackSize: leMaxStackSizeHandler;
  374.     leLongStrings: leLongStringsHandler;
  375.     leDenyPackageUnit: leDenyPackageUnitHandler;
  376.     leExternalSym: leExternalSymHandler;
  377.     leOpenStrings: leOpenStringsHandler;
  378.     leOverFlowChecks: leOverFlowChecksHandler;
  379.     leWriteableConst: leWriteableConstHandler;
  380.     leOptimization: leOptimizationHandler;
  381.     leVarStringChecks: leVarStringChecksHandler;
  382.     leExtendedSyntax: leExtendedSyntaxHandler;
  383.     leRealCompatibility: leRealCompatibilityHandler;
  384.     leResourceReserve: leResourceReserveHandler;
  385.     leRegion: leRegionHandler;
  386.     leEndRegion: leEndRegionHandler;
  387.   end;
  388. end;
  389.  
  390. function TmwDelphiDirectiveParser.EvaluateDirectiveExpression(
  391.   ConstTypeOne: Integer; ConstOne: AnsiString; RelationType,
  392.   ConstTypeTwo: Integer; ConstTwo: AnsiString): Boolean;
  393. begin
  394.   // To be implemented in derived classes
  395.   Result := False;
  396. end;
  397.  
  398. procedure TmwDelphiDirectiveParser.FindDirectiveEnd;
  399. var
  400.   TempRange: TmwDelphiRange;
  401. begin
  402.   TempRange := Range;
  403.   while (Id <> leAtEnd) and (Range <> drNormal) do
  404.     Next;
  405.   case Id of
  406.     leCurlyClose:
  407.       case TempRange of
  408.         drBorlandDirective: Id := leBorlandDirective;
  409.       else Id := leUnknownDirective;
  410.       end;
  411.     leEndOfAnsiComment:
  412.       case TempRange of
  413.         drAnsiDirective: Id := leAnsiDirective;
  414.       else Id := leUnknownDirective;
  415.       end;
  416.   else Id := leUnknownDirective;
  417.   end;
  418. end;
  419.  
  420. procedure TmwDelphiDirectiveParser.IncludeFile(FileName: AnsiString);
  421. begin
  422.  
  423. end;
  424.  
  425. procedure TmwDelphiDirectiveParser.MainDirectiveHandler;
  426. var
  427.   TempStart: Integer;
  428. begin
  429.   TempStart := Start;
  430.   Next;
  431.   case Id of
  432.     leA: leAHandler;
  433.     leB: leBHandler;
  434.     leC: leCHandler;
  435.     leD: leDHandler;
  436.     leE: leEHandler;
  437.     leG: leGHandler;
  438.     leH: leHHandler;
  439.     leI: leIHandler;
  440.     leJ: leJHandler;
  441.     leL: leLHandler;
  442.     leM: leMHandler;
  443.     leO: leOHandler;
  444.     leP: lePHandler;
  445.     leQ: leQHandler;
  446.     leR: leRHandler;
  447.     leS: leSHandler;
  448.     leT: leTHandler;
  449.     leU: leUHandler;
  450.     leV: leVHandler;
  451.     leW: leWHandler;
  452.     leX: leXHandler;
  453.     leY: leYHandler;
  454.     leZ: leZHandler;
  455.     leYD: leYDHandler;
  456.     leIfDirective: leIfDirectiveHandler;
  457.     leIfDef: leIfDefHandler;
  458.     leEndIf: leEndIfHandler;
  459.     leIfEnd: leIfEndHandler;
  460.     leElseDirective: leElseDirectiveHandler;
  461.     leDefine: leDefineHandler;
  462.     leAlign: leAlignHandler;
  463.     leIfNDef: leIfNDefHandler;
  464.     leLink: leLinkHandler;
  465.     leUnDef: leUnDefHandler;
  466.     leElseIf: leElseIfHandler;
  467.     leImageBase: leImageBaseHandler;
  468.     leIfOpt: leIfOptHandler;
  469.     leSoName: leSoNameHandler;
  470.     leInclude: leIncludeHandler;
  471.     leHints: leHintsHandler;
  472.     leNoDefine: leNoDefineHandler;
  473.     leIOChecks: leIOChecksHandler;
  474.     leDebugInfo: leDebugInfoHandler;
  475.     leBooleval: leBoolevalHandler;
  476.     leHPPEmit: leHPPEmitHandler;
  477.     leRangeChecks: leRangeChecksHandler;
  478.     leNoInclude: leNoIncludeHandler;
  479.     leApptype: leApptypeHandler;
  480.     leSafeDivide: leSafeDivideHandler;
  481.     leResource: leResourceHandler;
  482.     leWarn: leWarnHandler;
  483.     leWarnings: leWarningsHandler;
  484.     leTypeInfo: leTypeInfoHandler;
  485.     leSoPrefix: leSoPrefixHandler;
  486.     leStackFrames: leStackFramesHandler;
  487.     leRunOnly: leRunOnlyHandler;
  488.     leSoSuffix: leSoSuffixHandler;
  489.     leReferenceInfo: leReferenceInfoHandler;
  490.     leDesignOnly: leDesignOnlyHandler;
  491.     leExtension: leExtensionHandler;
  492.     leImportedData: leImportedDataHandler;
  493.     leDescription: leDescriptionHandler;
  494.     leSoVersion: leSoVersionHandler;
  495.     leAssertions: leAssertionsHandler;
  496.     leImplicitBuild: leImplicitBuildHandler;
  497.     leTypedAddress: leTypedAddressHandler;
  498.     leLocalSymbols: leLocalSymbolsHandler;
  499.     leMinEnumSize: leMinEnumSizeHandler;
  500.     leWeakPackageUnit: leWeakPackageUnitHandler;
  501.     leDefinitionInfo: leDefinitionInfoHandler;
  502.     leMinStackSize: leMinStackSizeHandler;
  503.     leObjExportAll: leObjExportAllHandler;
  504.     leMaxStackSize: leMaxStackSizeHandler;
  505.     leLongStrings: leLongStringsHandler;
  506.     leDenyPackageUnit: leDenyPackageUnitHandler;
  507.     leExternalSym: leExternalSymHandler;
  508.     leOpenStrings: leOpenStringsHandler;
  509.     leOverFlowChecks: leOverFlowChecksHandler;
  510.     leWriteableConst: leWriteableConstHandler;
  511.     leOptimization: leOptimizationHandler;
  512.     leVarStringChecks: leVarStringChecksHandler;
  513.     leExtendedSyntax: leExtendedSyntaxHandler;
  514.     leRealCompatibility: leRealCompatibilityHandler;
  515.     leResourceReserve: leResourceReserveHandler;
  516.     leRegion: leRegionHandler;
  517.     leEndRegion: leEndRegionHandler;
  518.   end;
  519.   Start := TempStart;
  520. end;
  521.  
  522. procedure TmwDelphiDirectiveParser.leAHandler;
  523. begin
  524.   Next;
  525.   case Id of
  526.     leMinus: Exclude(fBooleanDirectives, bdAlign);
  527.     leNumber:
  528.       case Run - Start = 1 of
  529.         True:
  530.           case Buf[Start] of
  531.             '1':
  532.               begin
  533.                 fRecordAlignment := 1;
  534.                 Exclude(fBooleanDirectives, bdAlign);
  535.               end;
  536.             '2':
  537.               begin
  538.                 fRecordAlignment := 2;
  539.                 Include(fBooleanDirectives, bdAlign);
  540.               end;
  541.             '4':
  542.               begin
  543.                 fRecordAlignment := 4;
  544.                 Include(fBooleanDirectives, bdAlign);
  545.               end;
  546.             '8':
  547.               begin
  548.                 fRecordAlignment := 8;
  549.                 Include(fBooleanDirectives, bdAlign);
  550.               end;
  551.           end;
  552.         False: Id := leUnknownDirective;
  553.       end;
  554.     lePlus: Include(fBooleanDirectives, bdAlign);
  555.   else Id := leUnknownDirective;
  556.   end;
  557.   if Id <> leUnknownDirective then
  558.     CheckCommaOrEnd;
  559. end;
  560.  
  561. procedure TmwDelphiDirectiveParser.leAlignHandler;
  562. begin
  563.   NextNoSpace;
  564.   case Id of
  565.     leNumber:
  566.       case Run - Start = 1 of
  567.         True:
  568.           case Buf[Start] of
  569.             '1':
  570.               begin
  571.                 fRecordAlignment := 1;
  572.                 Exclude(fBooleanDirectives, bdAlign);
  573.               end;
  574.             '2':
  575.               begin
  576.                 fRecordAlignment := 2;
  577.                 Include(fBooleanDirectives, bdAlign);
  578.               end;
  579.             '4':
  580.               begin
  581.                 fRecordAlignment := 4;
  582.                 Include(fBooleanDirectives, bdAlign);
  583.               end;
  584.             '8':
  585.               begin
  586.                 fRecordAlignment := 8;
  587.                 Include(fBooleanDirectives, bdAlign);
  588.               end;
  589.           end;
  590.         False: Id := leUnknownDirective;
  591.       end;
  592.     leOff: Exclude(fBooleanDirectives, bdAlign);
  593.     leOnDirective: Include(fBooleanDirectives, bdAlign);
  594.   else Id := leUnknownDirective;
  595.   end;
  596.   if Id <> leUnknownDirective then
  597.     CheckCommaOrEnd;
  598. end;
  599.  
  600. procedure TmwDelphiDirectiveParser.leApptypeHandler;
  601. begin
  602.   NextNoSpace;
  603.   case Id of
  604.     leConsole: fApptype := atConsole;
  605.     leGUI: fApptype := atGUI;
  606.   else Id := leUnknownDirective;
  607.   end;
  608.   if Id <> leUnknownDirective then
  609.     CheckCommaOrEnd;
  610. end;
  611.  
  612. procedure TmwDelphiDirectiveParser.leAssertionsHandler;
  613. begin
  614.   NextNoSpace;
  615.   case Id of
  616.     leOff: Exclude(fBooleanDirectives, bdAssertions);
  617.     leOnDirective: Include(fBooleanDirectives, bdAssertions);
  618.   else Id := leUnknownDirective;
  619.   end;
  620.   if Id <> leUnknownDirective then
  621.     CheckCommaOrEnd;
  622. end;
  623.  
  624. procedure TmwDelphiDirectiveParser.leBHandler;
  625. begin
  626.   Next;
  627.   case Id of
  628.     leMinus: Exclude(fBooleanDirectives, bdBoolEval);
  629.     lePlus: Include(fBooleanDirectives, bdBoolEval);
  630.   else Id := leUnknownDirective;
  631.   end;
  632.   if Id <> leUnknownDirective then
  633.     CheckCommaOrEnd;
  634. end;
  635.  
  636. procedure TmwDelphiDirectiveParser.leBoolevalHandler;
  637. begin
  638.   NextNoSpace;
  639.   case Id of
  640.     leOff: Exclude(fBooleanDirectives, bdBooleval);
  641.     leOnDirective: Include(fBooleanDirectives, bdBooleval);
  642.   else Id := leUnknownDirective;
  643.   end;
  644.   if Id <> leUnknownDirective then
  645.     CheckCommaOrEnd;
  646. end;
  647.  
  648. procedure TmwDelphiDirectiveParser.leCHandler;
  649. begin
  650.   Next;
  651.   case Id of
  652.     leMinus: Exclude(fBooleanDirectives, bdAssertions);
  653.     lePlus: Include(fBooleanDirectives, bdAssertions);
  654.   else Id := leUnknownDirective;
  655.   end;
  656.   if Id <> leUnknownDirective then
  657.     CheckCommaOrEnd;
  658. end;
  659.  
  660. procedure TmwDelphiDirectiveParser.leDebugInfoHandler;
  661. begin
  662.   NextNoSpace;
  663.   case Id of
  664.     leOff: Exclude(fBooleanDirectives, bdDebugInfo);
  665.     leOnDirective: Include(fBooleanDirectives, bdDebugInfo);
  666.   else Id := leUnknownDirective;
  667.   end;
  668.   if Id <> leUnknownDirective then
  669.     CheckCommaOrEnd;
  670. end;
  671.  
  672. procedure TmwDelphiDirectiveParser.leDefineHandler;
  673. begin
  674.   NextNoSpace;
  675.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  676.     True: fDefinedList.Add(Token);
  677.   else Id := leUnknownDirective;
  678.   end;
  679.   if Id <> leUnknownDirective then
  680.     CheckCommaOrEnd;
  681. end;
  682.  
  683. procedure TmwDelphiDirectiveParser.leDefinitionInfoHandler;
  684. begin
  685.   NextNoSpace;
  686.   case Id of
  687.     leOff: Exclude(fBooleanDirectives, bdDefinitionInfo);
  688.     leOnDirective: Include(fBooleanDirectives, bdDefinitionInfo);
  689.   else Id := leUnknownDirective;
  690.   end;
  691.   if Id <> leUnknownDirective then
  692.     CheckCommaOrEnd;
  693. end;
  694.  
  695. procedure TmwDelphiDirectiveParser.leDenyPackageUnitHandler;
  696. begin
  697.   NextNoSpace;
  698.   case Id of
  699.     leOff: Exclude(fBooleanDirectives, bdDenyPackageUnit);
  700.     leOnDirective: Include(fBooleanDirectives, bdDenyPackageUnit);
  701.   else Id := leUnknownDirective;
  702.   end;
  703.   if Id <> leUnknownDirective then
  704.     CheckCommaOrEnd;
  705. end;
  706.  
  707. procedure TmwDelphiDirectiveParser.leDescriptionHandler;
  708. var
  709.   Temp: AnsiString;
  710. begin
  711.   NextNoSpace;
  712.   case Id of
  713.     leStringConstant:
  714.       begin
  715.         SetLength(Temp, Run - Start - 2);
  716. {$IFDEF CLR}
  717.         System.array.Copy(Buf, Start + 1, Temp, 0, Run - Start - 2);
  718. {$ELSE}
  719.         System.Move(Buf[Start + 1], Temp[1], Run - Start - 2);
  720. {$ENDIF}
  721.         SetDescription(Temp);
  722.         CheckCommaOrEnd;
  723.       end;
  724.   else Id := leUnknownDirective;
  725.   end;
  726. end;
  727.  
  728. procedure TmwDelphiDirectiveParser.leDesignOnlyHandler;
  729. begin
  730.   NextNoSpace;
  731.   case Id of
  732.     leOff: Exclude(fBooleanDirectives, bdDesignOnly);
  733.     leOnDirective: Include(fBooleanDirectives, bdDesignOnly);
  734.   else Id := leUnknownDirective;
  735.   end;
  736.   if Id <> leUnknownDirective then
  737.     CheckCommaOrEnd;
  738. end;
  739.  
  740. procedure TmwDelphiDirectiveParser.leDHandler;
  741. begin
  742.   Next;
  743.   case Id of
  744.     leMinus: Exclude(fBooleanDirectives, bdDebugInfo);
  745.     lePlus: Include(fBooleanDirectives, bdDebugInfo);
  746.   else Id := leUnknownDirective;
  747.   end;
  748.   if Id <> leUnknownDirective then
  749.     CheckCommaOrEnd;
  750. end;
  751.  
  752. procedure TmwDelphiDirectiveParser.leEHandler;
  753. begin
  754.   NextNoSpace;
  755.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  756.     True: SetExtension(Token);
  757.   else Id := leUnknownDirective;
  758.   end;
  759.   if Id <> leUnknownDirective then
  760.   begin
  761.     CheckCommaOrEnd;
  762.   end;
  763. end;
  764.  
  765. procedure TmwDelphiDirectiveParser.leElseDirectiveHandler;
  766. var
  767.   Condition: Boolean;
  768. begin
  769.   FindDirectiveEnd;
  770.   Condition := False;
  771.   if Id <> leUnknownDirective then
  772.   begin
  773.     Id := leElseDirective;
  774.     if DirectiveStack.Count > 0 then
  775.       case Integer(DirectiveStack.Peek) of
  776.         leIfDef, leIfNDef, leIfOpt,
  777.         leElseIf:
  778.           Condition := True;
  779.       end;
  780.     case Condition of
  781.       True:
  782.         begin
  783.           DirectiveStack.Pop;
  784.           DirectiveStack.Push(TObject(Integer(leElseDirective)));
  785.           Next;
  786.           SkipUntilEndIf;
  787.         end;
  788.       False:
  789.         begin
  790.           if Assigned(fOnLexerError) then
  791.             fOnLexerError(Self, 'Else directive without previous leIfDef, leIfNDef or leIfOpt directive');
  792.         end;
  793.     end;
  794.   end;
  795. end;
  796.  
  797. procedure TmwDelphiDirectiveParser.leElseIfHandler;
  798. var
  799.   Condition: Boolean;
  800. begin
  801.   FindDirectiveEnd;
  802.   Condition := False;
  803.   if Id <> leUnknownDirective then
  804.   begin
  805.     Id := leElseIf;
  806.     if DirectiveStack.Count > 0 then
  807.       case Integer(DirectiveStack.Peek) of
  808.         leIfDirective: Condition := True;
  809.       end;
  810.     case Condition of
  811.       True:
  812.         begin
  813.           DirectiveStack.Pop;
  814.           DirectiveStack.Push(TObject(Integer(leElseIf)));
  815.           Next;
  816.           SkipUntilIfEnd;
  817.         end;
  818.       False:
  819.         begin
  820.           if Assigned(fOnLexerError) then
  821.             fOnLexerError(Self, 'ElseIf without previous If directive');
  822.         end;
  823.     end;
  824.   end;
  825. end;
  826.  
  827. procedure TmwDelphiDirectiveParser.leEndIfHandler;
  828. var
  829.   Condition: Boolean;
  830. begin
  831.   FindDirectiveEnd;
  832.   Condition := False;
  833.   if Id <> leUnknownDirective then
  834.   begin
  835.     id := leEndIf;
  836.     if DirectiveStack.Count > 0 then
  837.       case Integer(DirectiveStack.Peek) of
  838.         leElseDirective, leIfDef, leIfNDef, leIfOpt: Condition := True;
  839.       end;
  840.     case Condition of
  841.       True: DirectiveStack.Pop;
  842.       False:
  843.         begin
  844.           if Assigned(fOnLexerError) then
  845.             fOnLexerError(Self, 'EndIf without previous IfDef, Else, IfNDef or IfOpt directive');
  846.         end;
  847.     end;
  848.   end;
  849. end;
  850.  
  851. procedure TmwDelphiDirectiveParser.leEndRegionHandler;
  852. begin
  853.   FindDirectiveEnd;
  854.   if Id <> leUnknownDirective then
  855.   begin
  856.     id := leEndRegion;
  857.   end;
  858. end;
  859.  
  860. procedure TmwDelphiDirectiveParser.leExtendedSyntaxHandler;
  861. begin
  862.   NextNoSpace;
  863.   case Id of
  864.     leOff: Exclude(fBooleanDirectives, bdExtendedSyntax);
  865.     leOnDirective: Include(fBooleanDirectives, bdExtendedSyntax);
  866.   else Id := leUnknownDirective;
  867.   end;
  868.   if Id <> leUnknownDirective then
  869.     CheckCommaOrEnd;
  870. end;
  871.  
  872. procedure TmwDelphiDirectiveParser.leExtensionHandler;
  873. begin
  874.   NextNoSpace;
  875.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  876.     True: SetExtension(Token);
  877.   else Id := leUnknownDirective;
  878.   end;
  879.   if Id <> leUnknownDirective then
  880.   begin
  881.     CheckCommaOrEnd;
  882.   end;
  883. end;
  884.  
  885. procedure TmwDelphiDirectiveParser.leExternalSymHandler;
  886. begin
  887.   NextNoSpace;
  888.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  889.     True: SetExternalSym(Token);
  890.   else Id := leUnknownDirective;
  891.   end;
  892.   if Id <> leUnknownDirective then
  893.   begin
  894.     CheckCommaOrEnd;
  895.   end;
  896. end;
  897.  
  898. procedure TmwDelphiDirectiveParser.leGHandler;
  899. begin
  900.   Next;
  901.   case Id of
  902.     leMinus: Exclude(fBooleanDirectives, bdImportedData);
  903.     lePlus: Include(fBooleanDirectives, bdImportedData);
  904.   else Id := leUnknownDirective;
  905.   end;
  906.   if Id <> leUnknownDirective then
  907.     CheckCommaOrEnd;
  908. end;
  909.  
  910. procedure TmwDelphiDirectiveParser.leHHandler;
  911. begin
  912.   Next;
  913.   case Id of
  914.     leMinus: Exclude(fBooleanDirectives, bdLongStrings);
  915.     lePlus: Include(fBooleanDirectives, bdLongStrings);
  916.   else Id := leUnknownDirective;
  917.   end;
  918.   if Id <> leUnknownDirective then
  919.     CheckCommaOrEnd;
  920. end;
  921.  
  922. procedure TmwDelphiDirectiveParser.leHintsHandler;
  923. begin
  924.   NextNoSpace;
  925.   case Id of
  926.     leOff: Exclude(fBooleanDirectives, bdHints);
  927.     leOnDirective: Include(fBooleanDirectives, bdHints);
  928.   else Id := leUnknownDirective;
  929.   end;
  930.   if Id <> leUnknownDirective then
  931.     CheckCommaOrEnd;
  932. end;
  933.  
  934. procedure TmwDelphiDirectiveParser.leHPPEmitHandler;
  935. var
  936.   Temp: AnsiString;
  937. begin
  938.   NextNoSpace;
  939.   case Id of
  940.     leStringConstant:
  941.       begin
  942.         if fEmitForHpp then
  943.         begin
  944.           SetLength(Temp, Run - Start - 2);
  945. {$IFDEF CLR}
  946.           System.array.Copy(Buf, Start + 1, Temp, 0, Run - Start - 2);
  947. {$ELSE}
  948.           System.Move(Buf[Start + 1], Temp[1], Run - Start - 2);
  949. {$ENDIF}
  950.           SetHppEmit(Temp);
  951.         end;
  952.         CheckCommaOrEnd;
  953.       end;
  954.   else Id := leUnknownDirective;
  955.   end;
  956. end;
  957.  
  958. procedure TmwDelphiDirectiveParser.leIfDefHandler;
  959. var
  960.   IsDefined: Boolean;
  961. begin
  962.   NextNoSpace;
  963.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  964.     True:
  965.       begin
  966.         IsDefined := DefinedList.IndexOf(Token) > -1;
  967.         FindDirectiveEnd;
  968.         Id := leIfDef;
  969.         DirectiveStack.Push(TObject(Integer(leIfDef)));
  970.         case IsDefined of
  971.           False:
  972.             begin
  973.               Next;
  974.               SkipUntilElseOrEndIf;
  975.             end;
  976.         end;
  977.       end;
  978.   else Id := leUnknownDirective;
  979.   end;
  980. end;
  981.  
  982. procedure TmwDelphiDirectiveParser.leIfDirectiveHandler;
  983. var
  984.   Condition: Boolean;
  985. begin
  986.   Condition := CheckIfDirective;
  987.   FindDirectiveEnd;
  988.   case Condition of
  989.     False:
  990.       begin
  991.         DirectiveStack.Push(TObject(Integer(leIfDirective)));
  992.         Next;
  993.         SkipUntilElseIfOrIfEnd;
  994.       end;
  995.   end;
  996. end;
  997.  
  998. procedure TmwDelphiDirectiveParser.leIfEndHandler;
  999. var
  1000.   Condition: Boolean;
  1001. begin
  1002.   FindDirectiveEnd;
  1003.   Condition := False;
  1004.   if Id <> leUnknownDirective then
  1005.   begin
  1006.     id := leIfEnd;
  1007.     if DirectiveStack.Count > 0 then
  1008.       case Integer(DirectiveStack.Peek) of
  1009.         leElseIf, leIfDirective,
  1010.         leElseDirective:
  1011.           Condition := True;
  1012.       end;
  1013.     case Condition of
  1014.       True: DirectiveStack.Pop;
  1015.       False:
  1016.         begin
  1017.           if Assigned(fOnLexerError) then
  1018.             fOnLexerError(Self, 'IfEnd without previous If or ElseIf directive');
  1019.         end;
  1020.     end;
  1021.   end;
  1022. end;
  1023.  
  1024. procedure TmwDelphiDirectiveParser.leIfNDefHandler;
  1025. var
  1026.   IsDefined: Boolean;
  1027. begin
  1028.   NextNoSpace;
  1029.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  1030.     True:
  1031.       begin
  1032.         IsDefined := DefinedList.IndexOf(Token) > -1;
  1033.         FindDirectiveEnd;
  1034.         Id := leIfNDef;
  1035.         DirectiveStack.Push(TObject(Integer(leIfNDef)));
  1036.         case IsDefined of
  1037.           True:
  1038.             begin
  1039.               Next;
  1040.               SkipUntilElseOrEndIf;
  1041.             end;
  1042.         end;
  1043.       end;
  1044.   else Id := leUnknownDirective;
  1045.   end;
  1046. end;
  1047.  
  1048. procedure TmwDelphiDirectiveParser.leIfOptHandler;
  1049. var
  1050.   Condition: Boolean;
  1051. begin
  1052.   Condition := False;
  1053.   NextNoSpace;
  1054.   case Id of
  1055.     leA:
  1056.       begin
  1057.         Next;
  1058.         case Id of
  1059.           leMinus: Condition := not (bdAlign in fBooleanDirectives);
  1060.           lePlus: Condition := bdAlign in fBooleanDirectives;
  1061.         else Id := leUnknownDirective;
  1062.         end;
  1063.       end;
  1064.     leB:
  1065.       begin
  1066.         Next;
  1067.         case Id of
  1068.           leMinus: Condition := not (bdBoolEval in fBooleanDirectives);
  1069.           lePlus: Condition := bdBoolEval in fBooleanDirectives;
  1070.         else Id := leUnknownDirective;
  1071.         end;
  1072.       end;
  1073.     leC:
  1074.       begin
  1075.         Next;
  1076.         case Id of
  1077.           leMinus: Condition := not (bdAssertions in fBooleanDirectives);
  1078.           lePlus: Condition := bdAssertions in fBooleanDirectives;
  1079.         else Id := leUnknownDirective;
  1080.         end;
  1081.       end;
  1082.     leD:
  1083.       begin
  1084.         Next;
  1085.         case Id of
  1086.           leMinus: Condition := not (bdDebugInfo in fBooleanDirectives);
  1087.           lePlus: Condition := bdDebugInfo in fBooleanDirectives;
  1088.         else Id := leUnknownDirective;
  1089.         end;
  1090.       end;
  1091.     leG:
  1092.       begin
  1093.         Next;
  1094.         case Id of
  1095.           leMinus: Condition := not (bdImportedData in fBooleanDirectives);
  1096.           lePlus: Condition := bdImportedData in fBooleanDirectives;
  1097.         else Id := leUnknownDirective;
  1098.         end;
  1099.       end;
  1100.     leH:
  1101.       begin
  1102.         Next;
  1103.         case Id of
  1104.           leMinus: Condition := not (bdLongStrings in fBooleanDirectives);
  1105.           lePlus: Condition := bdLongStrings in fBooleanDirectives;
  1106.         else Id := leUnknownDirective;
  1107.         end;
  1108.       end;
  1109.     leI:
  1110.       begin
  1111.         Next;
  1112.         case Id of
  1113.           leMinus: Condition := not (bdIoChecks in fBooleanDirectives);
  1114.           lePlus: Condition := bdIoChecks in fBooleanDirectives;
  1115.         else Id := leUnknownDirective;
  1116.         end;
  1117.       end;
  1118.     leJ:
  1119.       begin
  1120.         Next;
  1121.         case Id of
  1122.           leMinus: Condition := not (bdWriteAbleConst in fBooleanDirectives);
  1123.           lePlus: Condition := bdWriteAbleConst in fBooleanDirectives;
  1124.         else Id := leUnknownDirective;
  1125.         end;
  1126.       end;
  1127.     leL:
  1128.       begin
  1129.         Next;
  1130.         case Id of
  1131.           leMinus: Condition := not (bdLocalSymbols in fBooleanDirectives);
  1132.           lePlus: Condition := bdLocalSymbols in fBooleanDirectives;
  1133.         else Id := leUnknownDirective;
  1134.         end;
  1135.       end;
  1136.     leM:
  1137.       begin
  1138.         Next;
  1139.         case Id of
  1140.           leMinus: Condition := not (bdTypeInfo in fBooleanDirectives);
  1141.           lePlus: Condition := bdTypeInfo in fBooleanDirectives;
  1142.         else Id := leUnknownDirective;
  1143.         end;
  1144.       end;
  1145.     leO:
  1146.       begin
  1147.         Next;
  1148.         case Id of
  1149.           leMinus: Condition := not (bdOptimization in fBooleanDirectives);
  1150.           lePlus: Condition := bdOptimization in fBooleanDirectives;
  1151.         else Id := leUnknownDirective;
  1152.         end;
  1153.       end;
  1154.     leP:
  1155.       begin
  1156.         Next;
  1157.         case Id of
  1158.           leMinus: Condition := not (bdOpenStrings in fBooleanDirectives);
  1159.           lePlus: Condition := bdOpenStrings in fBooleanDirectives;
  1160.         else Id := leUnknownDirective;
  1161.         end;
  1162.       end;
  1163.     leQ:
  1164.       begin
  1165.         Next;
  1166.         case Id of
  1167.           leMinus: Condition := not (bdOverflowChecks in fBooleanDirectives);
  1168.           lePlus: Condition := bdOverflowChecks in fBooleanDirectives;
  1169.         else Id := leUnknownDirective;
  1170.         end;
  1171.       end;
  1172.     leR:
  1173.       begin
  1174.         Next;
  1175.         case Id of
  1176.           leMinus: Condition := not (bdRangeChecks in fBooleanDirectives);
  1177.           lePlus: Condition := bdRangeChecks in fBooleanDirectives;
  1178.         else Id := leUnknownDirective;
  1179.         end;
  1180.       end;
  1181.     leS:
  1182.       begin
  1183.         Next;
  1184.         case Id of
  1185.           leMinus: Condition := not (bdStackChecks in fBooleanDirectives);
  1186.           lePlus: Condition := bdStackChecks in fBooleanDirectives;
  1187.         else Id := leUnknownDirective;
  1188.         end;
  1189.       end;
  1190.     leT:
  1191.       begin
  1192.         Next;
  1193.         case Id of
  1194.           leMinus: Condition := not (bdTypedAddress in fBooleanDirectives);
  1195.           lePlus: Condition := bdTypedAddress in fBooleanDirectives;
  1196.         else Id := leUnknownDirective;
  1197.         end;
  1198.       end;
  1199.     leU:
  1200.       begin
  1201.         Next;
  1202.         case Id of
  1203.           leMinus: Condition := not (bdSafeDivide in fBooleanDirectives);
  1204.           lePlus: Condition := bdSafeDivide in fBooleanDirectives;
  1205.         else Id := leUnknownDirective;
  1206.         end;
  1207.       end;
  1208.     leV:
  1209.       begin
  1210.         Next;
  1211.         case Id of
  1212.           leMinus: Condition := not (bdVarStringChecks in fBooleanDirectives);
  1213.           lePlus: Condition := bdVarStringChecks in fBooleanDirectives;
  1214.         else Id := leUnknownDirective;
  1215.         end;
  1216.       end;
  1217.     leW:
  1218.       begin
  1219.         Next;
  1220.         case Id of
  1221.           leMinus: Condition := not (bdStackFrames in fBooleanDirectives);
  1222.           lePlus: Condition := bdStackFrames in fBooleanDirectives;
  1223.         else Id := leUnknownDirective;
  1224.         end;
  1225.       end;
  1226.     leX:
  1227.       begin
  1228.         Next;
  1229.         case Id of
  1230.           leMinus: Condition := not (bdExtendedSyntax in fBooleanDirectives);
  1231.           lePlus: Condition := bdExtendedSyntax in fBooleanDirectives;
  1232.         else Id := leUnknownDirective;
  1233.         end;
  1234.       end;
  1235.     leY:
  1236.       begin
  1237.         Next;
  1238.         case Id of
  1239.           leMinus: Condition := not (bdDefinitionInfo in fBooleanDirectives);
  1240.           lePlus: Condition := bdDefinitionInfo in fBooleanDirectives;
  1241.         else Id := leUnknownDirective;
  1242.         end;
  1243.       end;
  1244.     leYD:
  1245.       begin
  1246.         FindDirectiveEnd;
  1247.         case Id <> leUnknownDirective of
  1248.           True: Condition := bdDefinitionInfo in fBooleanDirectives;
  1249.           False: Id := leUnknownDirective;
  1250.         end;
  1251.       end;
  1252.     leAlign:
  1253.       begin
  1254.         NextNoSpace;
  1255.         case Id of
  1256.           leOff: Condition := not (bdAlign in fBooleanDirectives);
  1257.           leOnDirective: Condition := bdAlign in fBooleanDirectives;
  1258.         else Id := leUnknownDirective;
  1259.         end;
  1260.       end;
  1261.     leAssertions:
  1262.       begin
  1263.         NextNoSpace;
  1264.         case Id of
  1265.           leOff: Condition := not (bdAssertions in fBooleanDirectives);
  1266.           leOnDirective: Condition := bdAssertions in fBooleanDirectives;
  1267.         else Id := leUnknownDirective;
  1268.         end;
  1269.       end;
  1270.     leBooleval:
  1271.       begin
  1272.         NextNoSpace;
  1273.         case Id of
  1274.           leOff: Condition := not (bdBooleval in fBooleanDirectives);
  1275.           leOnDirective: Condition := bdBooleval in fBooleanDirectives;
  1276.         else Id := leUnknownDirective;
  1277.         end;
  1278.       end;
  1279.     leDebugInfo:
  1280.       begin
  1281.         NextNoSpace;
  1282.         case Id of
  1283.           leOff: Condition := not (bdDebugInfo in fBooleanDirectives);
  1284.           leOnDirective: Condition := bdDebugInfo in fBooleanDirectives;
  1285.         else Id := leUnknownDirective;
  1286.         end;
  1287.       end;
  1288.     leDenyPackageUnit:
  1289.       begin
  1290.         NextNoSpace;
  1291.         case Id of
  1292.           leOff: Condition := not (bdDenyPackageUnit in fBooleanDirectives);
  1293.           leOnDirective: Condition := bdDenyPackageUnit in fBooleanDirectives;
  1294.         else Id := leUnknownDirective;
  1295.         end;
  1296.       end;
  1297.     leDesignOnly:
  1298.       begin
  1299.         NextNoSpace;
  1300.         case Id of
  1301.           leOff: Condition := not (bdDesignOnly in fBooleanDirectives);
  1302.           leOnDirective: Condition := bdDesignOnly in fBooleanDirectives;
  1303.         else Id := leUnknownDirective;
  1304.         end;
  1305.       end;
  1306.     leObjExportAll:
  1307.       begin
  1308.         NextNoSpace;
  1309.         case Id of
  1310.           leOff: Condition := not (bdObjExportAll in fBooleanDirectives);
  1311.           leOnDirective: Condition := bdObjExportAll in fBooleanDirectives;
  1312.         else Id := leUnknownDirective;
  1313.         end;
  1314.       end;
  1315.     leExtendedSyntax:
  1316.       begin
  1317.         NextNoSpace;
  1318.         case Id of
  1319.           leOff: Condition := not (bdExtendedSyntax in fBooleanDirectives);
  1320.           leOnDirective: Condition := bdExtendedSyntax in fBooleanDirectives;
  1321.         else Id := leUnknownDirective;
  1322.         end;
  1323.       end;
  1324.     leHints:
  1325.       begin
  1326.         NextNoSpace;
  1327.         case Id of
  1328.           leOff: Condition := not (bdHints in fBooleanDirectives);
  1329.           leOnDirective: Condition := bdHints in fBooleanDirectives;
  1330.         else Id := leUnknownDirective;
  1331.         end;
  1332.       end;
  1333.     leImplicitBuild:
  1334.       begin
  1335.         NextNoSpace;
  1336.         case Id of
  1337.           leOff: Condition := not (bdImplicitBuild in fBooleanDirectives);
  1338.           leOnDirective: Condition := bdImplicitBuild in fBooleanDirectives;
  1339.         else Id := leUnknownDirective;
  1340.         end;
  1341.       end;
  1342.     leImportedData:
  1343.       begin
  1344.         NextNoSpace;
  1345.         case Id of
  1346.           leOff: Condition := not (bdImportedData in fBooleanDirectives);
  1347.           leOnDirective: Condition := bdImportedData in fBooleanDirectives;
  1348.         else Id := leUnknownDirective;
  1349.         end;
  1350.       end;
  1351.     leIOChecks:
  1352.       begin
  1353.         NextNoSpace;
  1354.         case Id of
  1355.           leOff: Condition := not (bdIOChecks in fBooleanDirectives);
  1356.           leOnDirective: Condition := bdIOChecks in fBooleanDirectives;
  1357.         else Id := leUnknownDirective;
  1358.         end;
  1359.       end;
  1360.     leLocalSymbols:
  1361.       begin
  1362.         NextNoSpace;
  1363.         case Id of
  1364.           leOff: Condition := not (bdLocalSymbols in fBooleanDirectives);
  1365.           leOnDirective: Condition := bdLocalSymbols in fBooleanDirectives;
  1366.         else Id := leUnknownDirective;
  1367.         end;
  1368.       end;
  1369.     leLongStrings:
  1370.       begin
  1371.         NextNoSpace;
  1372.         case Id of
  1373.           leOff: Condition := not (bdLongStrings in fBooleanDirectives);
  1374.           leOnDirective: Condition := bdLongStrings in fBooleanDirectives;
  1375.         else Id := leUnknownDirective;
  1376.         end;
  1377.       end;
  1378.     leOpenStrings:
  1379.       begin
  1380.         NextNoSpace;
  1381.         case Id of
  1382.           leOff: Condition := not (bdOpenStrings in fBooleanDirectives);
  1383.           leOnDirective: Condition := bdOpenStrings in fBooleanDirectives;
  1384.         else Id := leUnknownDirective;
  1385.         end;
  1386.       end;
  1387.     leOptimization:
  1388.       begin
  1389.         NextNoSpace;
  1390.         case Id of
  1391.           leOff: Condition := not (bdOptimization in fBooleanDirectives);
  1392.           leOnDirective: Condition := bdOptimization in fBooleanDirectives;
  1393.         else Id := leUnknownDirective;
  1394.         end;
  1395.       end;
  1396.     leOverFlowChecks:
  1397.       begin
  1398.         NextNoSpace;
  1399.         case Id of
  1400.           leOff: Condition := not (bdOverFlowChecks in fBooleanDirectives);
  1401.           leOnDirective: Condition := bdOverFlowChecks in fBooleanDirectives;
  1402.         else Id := leUnknownDirective;
  1403.         end;
  1404.       end;
  1405.     leRangeChecks:
  1406.       begin
  1407.         NextNoSpace;
  1408.         case Id of
  1409.           leOff: Condition := not (bdRangeChecks in fBooleanDirectives);
  1410.           leOnDirective: Condition := bdRangeChecks in fBooleanDirectives;
  1411.         else Id := leUnknownDirective;
  1412.         end;
  1413.       end;
  1414.     leRealCompatibility:
  1415.       begin
  1416.         NextNoSpace;
  1417.         case Id of
  1418.           leOff: Condition := not (bdRealCompatibility in fBooleanDirectives);
  1419.           leOnDirective: Condition := bdRealCompatibility in fBooleanDirectives;
  1420.         else Id := leUnknownDirective;
  1421.         end;
  1422.       end;
  1423.     leRunOnly:
  1424.       begin
  1425.         NextNoSpace;
  1426.         case Id of
  1427.           leOff: Condition := not (bdRunOnly in fBooleanDirectives);
  1428.           leOnDirective: Condition := bdRunOnly in fBooleanDirectives;
  1429.         else Id := leUnknownDirective;
  1430.         end;
  1431.       end;
  1432.     leStackChecks:
  1433.       begin
  1434.         NextNoSpace;
  1435.         case Id of
  1436.           leOff: Condition := not (bdStackChecks in fBooleanDirectives);
  1437.           leOnDirective: Condition := bdStackChecks in fBooleanDirectives;
  1438.         else Id := leUnknownDirective;
  1439.         end;
  1440.       end;
  1441.     leTypeInfo:
  1442.       begin
  1443.         NextNoSpace;
  1444.         case Id of
  1445.           leOff: Condition := not (bdTypeInfo in fBooleanDirectives);
  1446.           leOnDirective: Condition := bdTypeInfo in fBooleanDirectives;
  1447.         else Id := leUnknownDirective;
  1448.         end;
  1449.       end;
  1450.     leDefinitionInfo:
  1451.       begin
  1452.         NextNoSpace;
  1453.         case Id of
  1454.           leOff: Condition := not (bdDefinitionInfo in fBooleanDirectives);
  1455.           leOnDirective: Condition := bdDefinitionInfo in fBooleanDirectives;
  1456.         else Id := leUnknownDirective;
  1457.         end;
  1458.       end;
  1459.     leSafeDivide:
  1460.       begin
  1461.         NextNoSpace;
  1462.         case Id of
  1463.           leOff: Condition := not (bdSafeDivide in fBooleanDirectives);
  1464.           leOnDirective: Condition := bdSafeDivide in fBooleanDirectives;
  1465.         else Id := leUnknownDirective;
  1466.         end;
  1467.       end;
  1468.     leTypedAddress:
  1469.       begin
  1470.         NextNoSpace;
  1471.         case Id of
  1472.           leOff: Condition := not (bdTypedAddress in fBooleanDirectives);
  1473.           leOnDirective: Condition := bdTypedAddress in fBooleanDirectives;
  1474.         else Id := leUnknownDirective;
  1475.         end;
  1476.       end;
  1477.     leVarStringChecks:
  1478.       begin
  1479.         NextNoSpace;
  1480.         case Id of
  1481.           leOff: Condition := not (bdVarStringChecks in fBooleanDirectives);
  1482.           leOnDirective: Condition := bdVarStringChecks in fBooleanDirectives;
  1483.         else Id := leUnknownDirective;
  1484.         end;
  1485.       end;
  1486.     leWarnings:
  1487.       begin
  1488.         NextNoSpace;
  1489.         case Id of
  1490.           leOff: Condition := not (bdWarnings in fBooleanDirectives);
  1491.           leOnDirective: Condition := bdWarnings in fBooleanDirectives;
  1492.         else Id := leUnknownDirective;
  1493.         end;
  1494.       end;
  1495.     leWeakPackageUnit:
  1496.       begin
  1497.         NextNoSpace;
  1498.         case Id of
  1499.           leOff: Condition := not (bdWeakPackageUnit in fBooleanDirectives);
  1500.           leOnDirective: Condition := bdWeakPackageUnit in fBooleanDirectives;
  1501.         else Id := leUnknownDirective;
  1502.         end;
  1503.       end;
  1504.     leStackFrames:
  1505.       begin
  1506.         NextNoSpace;
  1507.         case Id of
  1508.           leOff: Condition := not (bdStackFrames in fBooleanDirectives);
  1509.           leOnDirective: Condition := bdStackFrames in fBooleanDirectives;
  1510.         else Id := leUnknownDirective;
  1511.         end;
  1512.       end;
  1513.     leWriteableConst:
  1514.       begin
  1515.         NextNoSpace;
  1516.         case Id of
  1517.           leOff: Condition := not (bdWriteableConst in fBooleanDirectives);
  1518.           leOnDirective: Condition := bdWriteableConst in fBooleanDirectives;
  1519.         else Id := leUnknownDirective;
  1520.         end;
  1521.       end;
  1522.   else Id := leUnknownDirective;
  1523.   end;
  1524.   if Id <> leUnknownDirective then
  1525.   begin
  1526.     FindDirectiveEnd;
  1527.     Id := leIfOpt;
  1528.     DirectiveStack.Push(TObject(Integer(leIfOpt)));
  1529.     if Condition = False then
  1530.     begin
  1531.       Next;
  1532.       SkipUntilElseOrEndIf;
  1533.     end;
  1534.   end;
  1535. end;
  1536.  
  1537. procedure TmwDelphiDirectiveParser.leIHandler;
  1538. var
  1539.   Temp: AnsiString;
  1540. begin
  1541.   Next;
  1542.   case Id of
  1543.     leMinus: Exclude(fBooleanDirectives, bdIOChecks);
  1544.     lePlus: Include(fBooleanDirectives, bdIOChecks);
  1545.     leSpace:
  1546.       begin
  1547.         NextNoSpace;
  1548.         case Id of
  1549.           leIdentifier: Temp := RetrieveIncludeFileName;
  1550.           leStringConstant:
  1551.             begin
  1552.               SetLength(Temp, Run - Start - 2);
  1553. {$IFDEF CLR}
  1554.               System.array.Copy(Buf, Start + 1, Temp, 0, Run - Start - 2);
  1555. {$ELSE}
  1556.               System.Move(Buf[Start + 1], Temp[1], Run - Start - 2);
  1557. {$ENDIF}
  1558.             end;
  1559.         else
  1560.           case ExId = leIdentifier of
  1561.             True: Temp := RetrieveIncludeFileName;
  1562.             False: Id := leUnknownDirective;
  1563.           end;
  1564.         end;
  1565.       end;
  1566.   else Id := leUnknownDirective;
  1567.   end;
  1568.   if Id <> leUnknownDirective then
  1569.     CheckCommaOrEnd;
  1570.   if Id <> leUnknownDirective then
  1571.     IncludeFile(Temp);
  1572. end;
  1573.  
  1574. procedure TmwDelphiDirectiveParser.leImageBaseHandler;
  1575. begin
  1576.   NextNoSpace;
  1577.   case Id of
  1578.     leHexNumber,
  1579.       leNumber: SetImageBase(StrToInt(Token));
  1580.   else Id := leUnknownDirective;
  1581.   end;
  1582.   if Id <> leUnknownDirective then
  1583.     CheckCommaOrEnd;
  1584. end;
  1585.  
  1586. procedure TmwDelphiDirectiveParser.leImplicitBuildHandler;
  1587. begin
  1588.   NextNoSpace;
  1589.   case Id of
  1590.     leOff: Exclude(fBooleanDirectives, bdImplicitBuild);
  1591.     leOnDirective: Include(fBooleanDirectives, bdImplicitBuild);
  1592.   else Id := leUnknownDirective;
  1593.   end;
  1594.   if Id <> leUnknownDirective then
  1595.     CheckCommaOrEnd;
  1596. end;
  1597.  
  1598. procedure TmwDelphiDirectiveParser.leImportedDataHandler;
  1599. begin
  1600.   NextNoSpace;
  1601.   case Id of
  1602.     leOff: Exclude(fBooleanDirectives, bdImportedData);
  1603.     leOnDirective: Include(fBooleanDirectives, bdImportedData);
  1604.   else Id := leUnknownDirective;
  1605.   end;
  1606.   if Id <> leUnknownDirective then
  1607.     CheckCommaOrEnd;
  1608. end;
  1609.  
  1610. procedure TmwDelphiDirectiveParser.leIncludeHandler;
  1611. var
  1612.   Temp: AnsiString;
  1613. begin
  1614.   NextNoSpace;
  1615.   case Id of
  1616.     leIdentifier: Temp := RetrieveIncludeFileName;
  1617.     leStringConstant:
  1618.       begin
  1619.         SetLength(Temp, Run - Start - 2);
  1620. {$IFDEF CLR}
  1621.         System.array.Copy(Buf, Start + 1, Temp, 0, Run - Start - 2);
  1622. {$ELSE}
  1623.         System.Move(Buf[Start + 1], Temp[1], Run - Start - 2);
  1624. {$ENDIF}
  1625.       end;
  1626.   else
  1627.     case ExId = leIdentifier of
  1628.       True: Temp := RetrieveIncludeFileName;
  1629.       False: Id := leUnknownDirective;
  1630.     end;
  1631.   end;
  1632.   if Id <> leUnknownDirective then
  1633.     CheckCommaOrEnd;
  1634.   if Id <> leUnknownDirective then
  1635.     IncludeFile(Temp);
  1636. end;
  1637.  
  1638. procedure TmwDelphiDirectiveParser.leIOChecksHandler;
  1639. begin
  1640.   NextNoSpace;
  1641.   case Id of
  1642.     leOf: Exclude(fBooleanDirectives, bdIOChecks);
  1643.     leOnDirective: Include(fBooleanDirectives, bdIOChecks);
  1644.   else Id := leUnknownDirective;
  1645.   end;
  1646.   if Id <> leUnknownDirective then
  1647.     CheckCommaOrEnd;
  1648. end;
  1649.  
  1650. procedure TmwDelphiDirectiveParser.leJHandler;
  1651. begin
  1652.   Next;
  1653.   case Id of
  1654.     leMinus: Exclude(fBooleanDirectives, bdWriteableConst);
  1655.     lePlus: Include(fBooleanDirectives, bdWriteableConst);
  1656.   else Id := leUnknownDirective;
  1657.   end;
  1658.   if Id <> leUnknownDirective then
  1659.     CheckCommaOrEnd;
  1660. end;
  1661.  
  1662. procedure TmwDelphiDirectiveParser.leLHandler;
  1663. begin
  1664.   Next;
  1665.   case Id of
  1666.     leMinus: Exclude(fBooleanDirectives, bdLocalSymbols);
  1667.     lePlus: Include(fBooleanDirectives, bdLocalSymbols);
  1668.     leSpace:
  1669.       begin
  1670.         NextNoSpace;
  1671.         case (Id = leIdentifier) or (ExId = leIdentifier) of
  1672.           True: LinkObjectFile(Token);
  1673.         else Id := leUnknownDirective;
  1674.         end;
  1675.       end;
  1676.   else Id := leUnknownDirective;
  1677.   end;
  1678.   if Id <> leUnknownDirective then
  1679.     CheckCommaOrEnd;
  1680. end;
  1681.  
  1682. procedure TmwDelphiDirectiveParser.leLinkHandler;
  1683. begin
  1684.   NextNoSpace;
  1685.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  1686.     True: LinkObjectFile(Token);
  1687.   else Id := leUnknownDirective;
  1688.   end;
  1689.   if Id <> leUnknownDirective then
  1690.     CheckCommaOrEnd;
  1691. end;
  1692.  
  1693. procedure TmwDelphiDirectiveParser.leLocalSymbolsHandler;
  1694. begin
  1695.   NextNoSpace;
  1696.   case Id of
  1697.     leOff: Exclude(fBooleanDirectives, bdLocalSymbols);
  1698.     leOnDirective: Include(fBooleanDirectives, bdLocalSymbols);
  1699.   else Id := leUnknownDirective;
  1700.   end;
  1701.   if Id <> leUnknownDirective then
  1702.     CheckCommaOrEnd;
  1703. end;
  1704.  
  1705. procedure TmwDelphiDirectiveParser.leLongStringsHandler;
  1706. begin
  1707.   NextNoSpace;
  1708.   case Id of
  1709.     leOff: Exclude(fBooleanDirectives, bdLongStrings);
  1710.     leOnDirective: Include(fBooleanDirectives, bdLongStrings);
  1711.   else Id := leUnknownDirective;
  1712.   end;
  1713.   if Id <> leUnknownDirective then
  1714.     CheckCommaOrEnd;
  1715. end;
  1716.  
  1717. procedure TmwDelphiDirectiveParser.leMaxStackSizeHandler;
  1718. begin
  1719.   NextNoSpace;
  1720.   case (Id = leHexNumber) or (Id = leNumber) of
  1721.     True: SetMaxStackSize(StrToInt(Token));
  1722.   else Id := leUnknownDirective;
  1723.   end;
  1724.   if Id <> leUnknownDirective then
  1725.     CheckCommaOrEnd;
  1726. end;
  1727.  
  1728. procedure TmwDelphiDirectiveParser.leMHandler;
  1729. var
  1730.   Temp: AnsiString;
  1731.   TempStart, TempRun: Integer;
  1732. begin
  1733.   Next;
  1734.   case Id of
  1735.     leMinus: Exclude(fBooleanDirectives, bdTypeInfo);
  1736.     lePlus: Include(fBooleanDirectives, bdTypeInfo);
  1737.     leSpace:
  1738.       begin
  1739.         NextNoSpace;
  1740.         case (Id = leIdentifier) or (ExId = leIdentifier) or
  1741.           (Id = leHexNumber) or (Id = leNumber) of
  1742.           True:
  1743.             begin
  1744.               Temp := Token;
  1745.               TempStart := Start;
  1746.               TempRun := Run;
  1747.               NextNoSpace;
  1748.               case Id = leComma of
  1749.                 True:
  1750.                   begin
  1751.                     NextNoSpace;
  1752.                     case (Id = leIdentifier) or (ExId = leIdentifier) or
  1753.                       (Id = leHexNumber) or (Id = leNumber) of
  1754.                       True:
  1755.                         begin
  1756.                           SetMinStackSize(StrToInt(Temp));
  1757.                           SetMaxStackSize(StrToInt(Token));
  1758.                         end;
  1759.                     else Id := leUnknownDirective;
  1760.                     end;
  1761.                   end;
  1762.                 False:
  1763.                   begin
  1764.                     Start := TempStart;
  1765.                     Run := TempRun;
  1766.                     SetResourceReserve(Temp);
  1767.                   end;
  1768.               end;
  1769.             end;
  1770.         else Id := leUnknownDirective;
  1771.         end;
  1772.       end;
  1773.   else Id := leUnknownDirective;
  1774.   end;
  1775.   if Id <> leUnknownDirective then
  1776.     CheckCommaOrEnd;
  1777. end;
  1778.  
  1779. procedure TmwDelphiDirectiveParser.leMinEnumSizeHandler;
  1780. var
  1781.   Temp: Integer;
  1782. begin
  1783.   NextNoSpace;
  1784.   case (Id = leNumber) of
  1785.     True:
  1786.       begin
  1787.         Temp := StrToInt(Token);
  1788.         case Temp of
  1789.           1, 2, 4: SetMinEnumSize(Temp);
  1790.         else Id := leUnknownDirective;
  1791.         end;
  1792.       end;
  1793.   else Id := leUnknownDirective;
  1794.   end;
  1795.   if Id <> leUnknownDirective then
  1796.   begin
  1797.     CheckCommaOrEnd;
  1798.   end;
  1799. end;
  1800.  
  1801. procedure TmwDelphiDirectiveParser.leMinStackSizeHandler;
  1802. begin
  1803.   NextNoSpace;
  1804.   case (Id = leHexNumber) or (Id = leNumber) of
  1805.     True: SetMinStackSize(StrToInt(Token));
  1806.   else Id := leUnknownDirective;
  1807.   end;
  1808.   if Id <> leUnknownDirective then
  1809.     CheckCommaOrEnd;
  1810. end;
  1811.  
  1812. procedure TmwDelphiDirectiveParser.leNoDefineHandler;
  1813. begin
  1814.   NextNoSpace;
  1815.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  1816.     True:
  1817.       if fEmitForHpp then
  1818.         SetNoDefine(Token);
  1819.   else Id := leUnknownDirective;
  1820.   end;
  1821.   if Id <> leUnknownDirective then
  1822.     CheckCommaOrEnd;
  1823. end;
  1824.  
  1825. procedure TmwDelphiDirectiveParser.leNoIncludeHandler;
  1826. begin
  1827.   NextNoSpace;
  1828.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  1829.     True:
  1830.       if fEmitForHpp then
  1831.         SetNoInclude(Token);
  1832.   else Id := leUnknownDirective;
  1833.   end;
  1834.   if Id <> leUnknownDirective then
  1835.     CheckCommaOrEnd;
  1836. end;
  1837.  
  1838. procedure TmwDelphiDirectiveParser.leObjExportAllHandler;
  1839. begin
  1840.   NextNoSpace;
  1841.   case Id of
  1842.     leOff: Exclude(fBooleanDirectives, bdObjExportAll);
  1843.     leOnDirective: Include(fBooleanDirectives, bdObjExportAll);
  1844.   else Id := leUnknownDirective;
  1845.   end;
  1846.   if Id <> leUnknownDirective then
  1847.     CheckCommaOrEnd;
  1848. end;
  1849.  
  1850. procedure TmwDelphiDirectiveParser.leOHandler;
  1851. begin
  1852.   Next;
  1853.   case Id of
  1854.     leMinus: Exclude(fBooleanDirectives, bdOptimization);
  1855.     lePlus: Include(fBooleanDirectives, bdOptimization);
  1856.   else Id := leUnknownDirective;
  1857.   end;
  1858.   if Id <> leUnknownDirective then
  1859.     CheckCommaOrEnd;
  1860. end;
  1861.  
  1862. procedure TmwDelphiDirectiveParser.leOpenStringsHandler;
  1863. begin
  1864.   NextNoSpace;
  1865.   case Id of
  1866.     leOff: Exclude(fBooleanDirectives, bdOpenStrings);
  1867.     leOnDirective: Include(fBooleanDirectives, bdOpenStrings);
  1868.   else Id := leUnknownDirective;
  1869.   end;
  1870.   if Id <> leUnknownDirective then
  1871.     CheckCommaOrEnd;
  1872. end;
  1873.  
  1874. procedure TmwDelphiDirectiveParser.leOptimizationHandler;
  1875. begin
  1876.   NextNoSpace;
  1877.   case Id of
  1878.     leOff: Exclude(fBooleanDirectives, bdOptimization);
  1879.     leOnDirective: Include(fBooleanDirectives, bdOptimization);
  1880.   else Id := leUnknownDirective;
  1881.   end;
  1882.   if Id <> leUnknownDirective then
  1883.     CheckCommaOrEnd;
  1884. end;
  1885.  
  1886. procedure TmwDelphiDirectiveParser.leOverFlowChecksHandler;
  1887. begin
  1888.   NextNoSpace;
  1889.   case Id of
  1890.     leOff: Exclude(fBooleanDirectives, bdOverFlowChecks);
  1891.     leOnDirective: Include(fBooleanDirectives, bdOverFlowChecks);
  1892.   else Id := leUnknownDirective;
  1893.   end;
  1894.   if Id <> leUnknownDirective then
  1895.     CheckCommaOrEnd;
  1896. end;
  1897.  
  1898. procedure TmwDelphiDirectiveParser.lePHandler;
  1899. begin
  1900.   Next;
  1901.   case Id of
  1902.     leMinus: Exclude(fBooleanDirectives, bdOpenStrings);
  1903.     lePlus: Include(fBooleanDirectives, bdOpenStrings);
  1904.   else Id := leUnknownDirective;
  1905.   end;
  1906.   if Id <> leUnknownDirective then
  1907.     CheckCommaOrEnd;
  1908. end;
  1909.  
  1910. procedure TmwDelphiDirectiveParser.leQHandler;
  1911. begin
  1912.   Next;
  1913.   case Id of
  1914.     leMinus: Exclude(fBooleanDirectives, bdOverFlowChecks);
  1915.     lePlus: Include(fBooleanDirectives, bdOverFlowChecks);
  1916.   else Id := leUnknownDirective;
  1917.   end;
  1918.   if Id <> leUnknownDirective then
  1919.     CheckCommaOrEnd;
  1920. end;
  1921.  
  1922. procedure TmwDelphiDirectiveParser.leRangeChecksHandler;
  1923. begin
  1924.   NextNoSpace;
  1925.   case Id of
  1926.     leOff: Exclude(fBooleanDirectives, bdRangeChecks);
  1927.     leOnDirective: Include(fBooleanDirectives, bdRangeChecks);
  1928.   else Id := leUnknownDirective;
  1929.   end;
  1930.   if Id <> leUnknownDirective then
  1931.     CheckCommaOrEnd;
  1932. end;
  1933.  
  1934. procedure TmwDelphiDirectiveParser.leRealCompatibilityHandler;
  1935. begin
  1936.   NextNoSpace;
  1937.   case Id of
  1938.     leOff: Exclude(fBooleanDirectives, bdRealCompatibility);
  1939.     leOnDirective: Include(fBooleanDirectives, bdRealCompatibility);
  1940.   else Id := leUnknownDirective;
  1941.   end;
  1942.   if Id <> leUnknownDirective then
  1943.     CheckCommaOrEnd;
  1944. end;
  1945.  
  1946. procedure TmwDelphiDirectiveParser.leReferenceInfoHandler;
  1947. begin
  1948.   NextNoSpace;
  1949.   case Id of
  1950.     leOff: Exclude(fBooleanDirectives, bdDefinitionInfo);
  1951.     leOnDirective: Include(fBooleanDirectives, bdDefinitionInfo);
  1952.   else Id := leUnknownDirective;
  1953.   end;
  1954.   if Id <> leUnknownDirective then
  1955.     CheckCommaOrEnd;
  1956. end;
  1957.  
  1958. procedure TmwDelphiDirectiveParser.leRegionHandler;
  1959. begin
  1960.   NextNoSpace;
  1961.   case Id of
  1962.     leStringConstant: SetRegionString(Token);
  1963.   else Id := leUnknownDirective;
  1964.   end;
  1965.   if Id <> leUnknownDirective then
  1966.     CheckCommaOrEnd;
  1967. end;
  1968.  
  1969. procedure TmwDelphiDirectiveParser.leResourceHandler;
  1970. begin
  1971.   NextNoSpace;
  1972.   SetResFileName(RetrieveResourceFileName);
  1973.   NextNoSpace;
  1974.   SetRcFileName(RetrieveResourceFileName);
  1975.   CheckCommaOrEnd;
  1976. end;
  1977.  
  1978. procedure TmwDelphiDirectiveParser.leResourceReserveHandler;
  1979. begin
  1980.   NextNoSpace;
  1981.   case (Id = leIdentifier) or (ExId = leIdentifier) or
  1982.     (Id = leHexNumber) or (Id = leNumber) of
  1983.     True: SetResourceReserve(Token);
  1984.   else Id := leUnknownDirective;
  1985.   end;
  1986.   if Id <> leUnknownDirective then
  1987.     CheckCommaOrEnd;
  1988. end;
  1989.  
  1990. procedure TmwDelphiDirectiveParser.leRHandler;
  1991. begin
  1992.   Next;
  1993.   case Id of
  1994.     leMinus: Exclude(fBooleanDirectives, bdRangeChecks);
  1995.     lePlus: Include(fBooleanDirectives, bdRangeChecks);
  1996.     leSpace:
  1997.       begin
  1998.         NextNoSpace;
  1999.         SetResFileName(RetrieveResourceFileName);
  2000.         NextNoSpace;
  2001.         SetRcFileName(RetrieveResourceFileName);
  2002.       end;
  2003.   else Id := leUnknownDirective;
  2004.   end;
  2005.   if Id <> leUnknownDirective then
  2006.     CheckCommaOrEnd;
  2007. end;
  2008.  
  2009. procedure TmwDelphiDirectiveParser.leRunOnlyHandler;
  2010. begin
  2011.   NextNoSpace;
  2012.   case Id of
  2013.     leOff: Exclude(fBooleanDirectives, bdRunOnly);
  2014.     leOnDirective: Include(fBooleanDirectives, bdRunOnly);
  2015.   else Id := leUnknownDirective;
  2016.   end;
  2017.   if Id <> leUnknownDirective then
  2018.     CheckCommaOrEnd;
  2019. end;
  2020.  
  2021. procedure TmwDelphiDirectiveParser.leSafeDivideHandler;
  2022. begin
  2023.   NextNoSpace;
  2024.   case Id of
  2025.     leOff: Exclude(fBooleanDirectives, bdSafeDivide);
  2026.     leOnDirective: Include(fBooleanDirectives, bdSafeDivide);
  2027.   else Id := leUnknownDirective;
  2028.   end;
  2029.   if Id <> leUnknownDirective then
  2030.     CheckCommaOrEnd;
  2031. end;
  2032.  
  2033. procedure TmwDelphiDirectiveParser.leSHandler;
  2034. begin
  2035.   Next;
  2036.   case Id of
  2037.     leMinus: Exclude(fBooleanDirectives, bdStackChecks);
  2038.     lePlus: Include(fBooleanDirectives, bdStackChecks);
  2039.   else Id := leUnknownDirective;
  2040.   end;
  2041.   if Id <> leUnknownDirective then
  2042.     CheckCommaOrEnd;
  2043. end;
  2044.  
  2045. procedure TmwDelphiDirectiveParser.leSoNameHandler;
  2046. begin
  2047.   //  ToDo
  2048. end;
  2049.  
  2050. procedure TmwDelphiDirectiveParser.leSoPrefixHandler;
  2051. begin
  2052.   //  ToDo
  2053. end;
  2054.  
  2055. procedure TmwDelphiDirectiveParser.leSoSuffixHandler;
  2056. begin
  2057.   //  ToDo
  2058. end;
  2059.  
  2060. procedure TmwDelphiDirectiveParser.leSoVersionHandler;
  2061. begin
  2062.   //  ToDo
  2063. end;
  2064.  
  2065. procedure TmwDelphiDirectiveParser.leStackChecksHandler;
  2066. begin
  2067.   NextNoSpace;
  2068.   case Id of
  2069.     leOf: Exclude(fBooleanDirectives, bdStackChecks);
  2070.     leOnDirective: Include(fBooleanDirectives, bdStackChecks);
  2071.   else Id := leUnknownDirective;
  2072.   end;
  2073.   if Id <> leUnknownDirective then
  2074.     CheckCommaOrEnd;
  2075. end;
  2076.  
  2077. procedure TmwDelphiDirectiveParser.leStackFramesHandler;
  2078. begin
  2079.   NextNoSpace;
  2080.   case Id of
  2081.     leOf: Exclude(fBooleanDirectives, bdStackFrames);
  2082.     leOnDirective: Include(fBooleanDirectives, bdStackFrames);
  2083.   else Id := leUnknownDirective;
  2084.   end;
  2085.   if Id <> leUnknownDirective then
  2086.     CheckCommaOrEnd;
  2087. end;
  2088.  
  2089. procedure TmwDelphiDirectiveParser.leTHandler;
  2090. begin
  2091.   Next;
  2092.   case Id of
  2093.     leMinus: Exclude(fBooleanDirectives, bdTypedAddress);
  2094.     lePlus: Include(fBooleanDirectives, bdTypedAddress);
  2095.   else Id := leUnknownDirective;
  2096.   end;
  2097.   if Id <> leUnknownDirective then
  2098.     CheckCommaOrEnd;
  2099. end;
  2100.  
  2101. procedure TmwDelphiDirectiveParser.leTypedAddressHandler;
  2102. begin
  2103.   NextNoSpace;
  2104.   case Id of
  2105.     leOf: Exclude(fBooleanDirectives, bdTypedAddress);
  2106.     leOnDirective: Include(fBooleanDirectives, bdTypedAddress);
  2107.   else Id := leUnknownDirective;
  2108.   end;
  2109.   if Id <> leUnknownDirective then
  2110.     CheckCommaOrEnd;
  2111. end;
  2112.  
  2113. procedure TmwDelphiDirectiveParser.leTypeInfoHandler;
  2114. begin
  2115.   NextNoSpace;
  2116.   case Id of
  2117.     leOf: Exclude(fBooleanDirectives, bdTypeInfo);
  2118.     leOnDirective: Include(fBooleanDirectives, bdTypeInfo);
  2119.   else Id := leUnknownDirective;
  2120.   end;
  2121.   if Id <> leUnknownDirective then
  2122.     CheckCommaOrEnd;
  2123. end;
  2124.  
  2125. procedure TmwDelphiDirectiveParser.leUHandler;
  2126. begin
  2127.   Next;
  2128.   case Id of
  2129.     leMinus: Exclude(fBooleanDirectives, bdSafeDivide);
  2130.     lePlus: Include(fBooleanDirectives, bdSafeDivide);
  2131.   else Id := leUnknownDirective;
  2132.   end;
  2133.   if Id <> leUnknownDirective then
  2134.     CheckCommaOrEnd;
  2135. end;
  2136.  
  2137. procedure TmwDelphiDirectiveParser.leUnDefHandler;
  2138. begin
  2139.   NextNoSpace;
  2140.   case (Id = leIdentifier) or (ExId = leIdentifier) of
  2141.     True: fDefinedList.Remove(Token);
  2142.   else Id := leUnknownDirective;
  2143.   end;
  2144.   if Id <> leUnknownDirective then
  2145.     CheckCommaOrEnd;
  2146. end;
  2147.  
  2148. procedure TmwDelphiDirectiveParser.leVarStringChecksHandler;
  2149. begin
  2150.   NextNoSpace;
  2151.   case Id of
  2152.     leOf: Exclude(fBooleanDirectives, bdVarStringChecks);
  2153.     leOnDirective: Include(fBooleanDirectives, bdVarStringChecks);
  2154.   else Id := leUnknownDirective;
  2155.   end;
  2156.   if Id <> leUnknownDirective then
  2157.     CheckCommaOrEnd;
  2158. end;
  2159.  
  2160. procedure TmwDelphiDirectiveParser.leVHandler;
  2161. begin
  2162.   Next;
  2163.   case Id of
  2164.     leMinus: Exclude(fBooleanDirectives, bdVarStringChecks);
  2165.     lePlus: Include(fBooleanDirectives, bdVarStringChecks);
  2166.   else Id := leUnknownDirective;
  2167.   end;
  2168.   if Id <> leUnknownDirective then
  2169.     CheckCommaOrEnd;
  2170. end;
  2171.  
  2172. procedure TmwDelphiDirectiveParser.leWarnHandler;
  2173. begin
  2174.   NextNoSpace;
  2175.   case Id of
  2176.     leOf: Exclude(fBooleanDirectives, bdWarnings);
  2177.     leOnDirective: Include(fBooleanDirectives, bdWarnings);
  2178.     leSymbol_Platform:
  2179.       begin
  2180.         NextNoSpace;
  2181.         case Id of
  2182.           leOf: Exclude(fBooleanDirectives, bdSymbol_Platform);
  2183.           leOnDirective: Include(fBooleanDirectives, bdSymbol_Platform);
  2184.         else Id := leUnknownDirective;
  2185.         end;
  2186.       end;
  2187.     leSymbol_Library:
  2188.       begin
  2189.         NextNoSpace;
  2190.         case Id of
  2191.           leOf: Exclude(fBooleanDirectives, bdSymbol_Library);
  2192.           leOnDirective: Include(fBooleanDirectives, bdSymbol_Library);
  2193.         else Id := leUnknownDirective;
  2194.         end;
  2195.       end;
  2196.     leSymbol_Deprecated:
  2197.       begin
  2198.         NextNoSpace;
  2199.         case Id of
  2200.           leOf: Exclude(fBooleanDirectives, bdSymbol_Deprecated);
  2201.           leOnDirective: Include(fBooleanDirectives, bdSymbol_Deprecated);
  2202.         else Id := leUnknownDirective;
  2203.         end;
  2204.       end;
  2205.     leUnit_Deprecated:
  2206.       begin
  2207.         NextNoSpace;
  2208.         case Id of
  2209.           leOf: Exclude(fBooleanDirectives, bdUnit_Deprecated);
  2210.           leOnDirective: Include(fBooleanDirectives, bdUnit_Deprecated);
  2211.         else Id := leUnknownDirective;
  2212.         end;
  2213.       end;
  2214.     leUnit_Library:
  2215.       begin
  2216.         NextNoSpace;
  2217.         case Id of
  2218.           leOf: Exclude(fBooleanDirectives, bdUnit_Library);
  2219.           leOnDirective: Include(fBooleanDirectives, bdUnit_Library);
  2220.         else Id := leUnknownDirective;
  2221.         end;
  2222.       end;
  2223.     leUnit_Platform:
  2224.       begin
  2225.         NextNoSpace;
  2226.         case Id of
  2227.           leOf: Exclude(fBooleanDirectives, bdUnit_Platform);
  2228.           leOnDirective: Include(fBooleanDirectives, bdUnit_Platform);
  2229.         else Id := leUnknownDirective;
  2230.         end;
  2231.       end;
  2232.   else Id := leUnknownDirective;
  2233.   end;
  2234.   if Id <> leUnknownDirective then
  2235.     CheckCommaOrEnd;
  2236. end;
  2237.  
  2238. procedure TmwDelphiDirectiveParser.leWarningsHandler;
  2239. begin
  2240.   NextNoSpace;
  2241.   case Id of
  2242.     leOf: Exclude(fBooleanDirectives, bdWarnings);
  2243.     leOnDirective: Include(fBooleanDirectives, bdWarnings);
  2244.   else Id := leUnknownDirective;
  2245.   end;
  2246.   if Id <> leUnknownDirective then
  2247.     CheckCommaOrEnd;
  2248. end;
  2249.  
  2250. procedure TmwDelphiDirectiveParser.leWeakPackageUnitHandler;
  2251. begin
  2252.   NextNoSpace;
  2253.   case Id of
  2254.     leOf: Exclude(fBooleanDirectives, bdWeakPackageUnit);
  2255.     leOnDirective: Include(fBooleanDirectives, bdWeakPackageUnit);
  2256.   else Id := leUnknownDirective;
  2257.   end;
  2258.   if Id <> leUnknownDirective then
  2259.     CheckCommaOrEnd;
  2260. end;
  2261.  
  2262. procedure TmwDelphiDirectiveParser.leWHandler;
  2263. begin
  2264.   Next;
  2265.   case Id of
  2266.     leMinus: Exclude(fBooleanDirectives, bdStackFrames);
  2267.     lePlus: Include(fBooleanDirectives, bdStackFrames);
  2268.   else Id := leUnknownDirective;
  2269.   end;
  2270.   if Id <> leUnknownDirective then
  2271.     CheckCommaOrEnd;
  2272. end;
  2273.  
  2274. procedure TmwDelphiDirectiveParser.leWriteableConstHandler;
  2275. begin
  2276.   NextNoSpace;
  2277.   case Id of
  2278.     leOf: Exclude(fBooleanDirectives, bdWriteableConst);
  2279.     leOnDirective: Include(fBooleanDirectives, bdWriteableConst);
  2280.   else Id := leUnknownDirective;
  2281.   end;
  2282.   if Id <> leUnknownDirective then
  2283.     CheckCommaOrEnd;
  2284. end;
  2285.  
  2286. procedure TmwDelphiDirectiveParser.leXHandler;
  2287. begin
  2288.   Next;
  2289.   case Id of
  2290.     leMinus: Exclude(fBooleanDirectives, bdExtendedSyntax);
  2291.     lePlus: Include(fBooleanDirectives, bdExtendedSyntax);
  2292.   else Id := leUnknownDirective;
  2293.   end;
  2294.   if Id <> leUnknownDirective then
  2295.     CheckCommaOrEnd;
  2296. end;
  2297.  
  2298. procedure TmwDelphiDirectiveParser.leYDHandler;
  2299. begin
  2300.   Include(fBooleanDirectives, bdDefinitionInfo);
  2301.   CheckCommaOrEnd;
  2302. end;
  2303.  
  2304. procedure TmwDelphiDirectiveParser.leYHandler;
  2305. begin
  2306.   Next;
  2307.   case Id of
  2308.     leMinus: Exclude(fBooleanDirectives, bdDefinitionInfo);
  2309.     lePlus: Include(fBooleanDirectives, bdDefinitionInfo);
  2310.   else Id := leUnknownDirective;
  2311.   end;
  2312.   if Id <> leUnknownDirective then
  2313.     CheckCommaOrEnd;
  2314. end;
  2315.  
  2316. procedure TmwDelphiDirectiveParser.leZHandler;
  2317. var
  2318.   Temp: Integer;
  2319. begin
  2320.   Next;
  2321.   case Id = leNumber of
  2322.     True:
  2323.       begin
  2324.         Temp := StrToInt(Token);
  2325.         case Temp of
  2326.           1, 2, 4: SetMinEnumSize(Temp);
  2327.         else Id := leUnknownDirective;
  2328.         end;
  2329.       end;
  2330.   else Id := leUnknownDirective;
  2331.   end;
  2332.   if Id <> leUnknownDirective then
  2333.   begin
  2334.     CheckCommaOrEnd;
  2335.   end;
  2336. end;
  2337.  
  2338. procedure TmwDelphiDirectiveParser.LinkObjectFile(FileName: AnsiString);
  2339. begin
  2340.  
  2341. end;
  2342.  
  2343. procedure TmwDelphiDirectiveParser.NextToken;
  2344. begin
  2345.   Start := Run;
  2346.   ExId := leUnknown;
  2347.   case Run < TheEnd of
  2348.     True:
  2349.       begin
  2350.         case Range of
  2351.           drNormal,
  2352.             drAnsiDirective,
  2353.             drBorlandDirective:
  2354.             case Buf[Run] of
  2355.               #0..#9: SpaceHandler;
  2356.               #10: LFHandler;
  2357.               #11, #12: SpaceHandler;
  2358.               #13: CRHandler;
  2359.               #14..#32: SpaceHandler;
  2360.               '!': ExclamHandler;
  2361.               '"': DoubleQuoteHandler;
  2362.               '#': SharpHandler;
  2363.               '$': DollarHandler;
  2364.               '%': PercentHandler;
  2365.               '&': AmpersandHandler;
  2366.               '''': ApostropheHandler;
  2367.               '(': RoundOpenHandler;
  2368.               ')': RoundCloseHandler;
  2369.               '*': AsteriskHandler;
  2370.               '+': PlusHandler;
  2371.               ',': CommaHandler;
  2372.               '-': MinusHandler;
  2373.               '.': PeriodHandler;
  2374.               '/': SlashHandler;
  2375.               '0'..'9': NumberHandler;
  2376.               ':': ColonHandler;
  2377.               ';': SemicolonHandler;
  2378.               '<': LessHandler;
  2379.               '=': EqualHandler;
  2380.               '>': GreaterHandler;
  2381.               '?': QuestionHandler;
  2382.               '@': AtHandler;
  2383.               'A'..'Z': IdentifierHandler;
  2384.               '[': SquareOpenHandler;
  2385.               '\': BackslashHandler;
  2386.               ']': SquareCloseHandler;
  2387.               '^': AsciiCircumHandler;
  2388.               '_': IdentifierHandler;
  2389.               '`': QuoteLeftHandler;
  2390.               'a'..'z': IdentifierHandler;
  2391.               '{': CurlyOpenHandler;
  2392.               '|': BarHandler;
  2393.               '}': CurlyCloseHandler;
  2394.               '~': AsciiTildeHandler;
  2395.             else
  2396.               case InInternationalIdentifiers[Buf[Run]] of
  2397.                 True: InternationalIdentifierHandler;
  2398.                 False:
  2399.                   case (Buf[Run] > #191) and (Run + UTF8Width[Buf[Run]] <= TheEnd) of
  2400.                     True: InternationalIdentifierHandler;
  2401.                     False: UnknownHandler;
  2402.                   end;
  2403.               end;
  2404.             end;
  2405.           drAssemblerReference: NextAssemblerReference;
  2406.           drAnsiComment: NextAnsiComment;
  2407.           drBorlandComment: NextBorlandComment;
  2408.         end;
  2409.         case Id of
  2410.           leBeginOfAnsiDirective,
  2411.             leBeginOfBorlandDirective:
  2412.             MainDirectiveHandler;
  2413.         end;
  2414.       end;
  2415.     False: Id := leAtEnd;
  2416.   end
  2417. end;
  2418.  
  2419. procedure TmwDelphiDirectiveParser.Parse;
  2420. begin
  2421.   while Id <> leAtEnd do
  2422.     NextToken;
  2423. end;
  2424.  
  2425. procedure TmwDelphiDirectiveParser.SkipUntilEndIf;
  2426. var
  2427.   Condition: Boolean;
  2428. begin
  2429.   Condition := False;
  2430.   while Id <> leAtEnd do
  2431.     case Id of
  2432.       leEndIf:
  2433.         begin
  2434.           if DirectiveStack.Count > 0 then
  2435.             case Integer(DirectiveStack.Peek) of
  2436.               leElseDirective, leIfDef, leIfNDef, leIfOpt: Condition := True;
  2437.             end;
  2438.           case Condition of
  2439.             True:
  2440.               begin
  2441.                 DirectiveStack.Pop;
  2442.                 FindDirectiveEnd;
  2443.                 Break;
  2444.               end;
  2445.             False:
  2446.               begin
  2447.                 if Assigned(fOnLexerError) then
  2448.                   fOnLexerError(Self, 'EndIf without previous IfDef, Else, IfNDef or IfOpt directive');
  2449.               end;
  2450.           end;
  2451.         end;
  2452.       leIfDef, leIfNDef, leIfOpt:
  2453.         begin
  2454.           DirectiveStack.Push(TObject(Id));
  2455.           FindDirectiveEnd;
  2456.           Next;
  2457.           SkipUntilEndIf;
  2458.         end;
  2459.     else Next;
  2460.     end;
  2461. end;
  2462.  
  2463. procedure TmwDelphiDirectiveParser.SkipUntilIfEnd;
  2464. var
  2465.   Condition: Boolean;
  2466. begin
  2467.   Condition := False;
  2468.   while Id <> leAtEnd do
  2469.     case Id of
  2470.       leIfEnd:
  2471.         begin
  2472.           if DirectiveStack.Count > 0 then
  2473.             case Integer(DirectiveStack.Peek) of
  2474.               leElseIf, leIfDirective: Condition := True;
  2475.             end;
  2476.           case Condition of
  2477.             True:
  2478.               begin
  2479.                 DirectiveStack.Pop;
  2480.                 FindDirectiveEnd;
  2481.                 Break;
  2482.               end;
  2483.             False:
  2484.               begin
  2485.                 if Assigned(fOnLexerError) then
  2486.                   fOnLexerError(Self, 'IfEnd without previous If or ElseIf directive');
  2487.               end;
  2488.           end;
  2489.         end;
  2490.       leIfDirective:
  2491.         begin
  2492.           DirectiveStack.Push(TObject(Id));
  2493.           FindDirectiveEnd;
  2494.           Next;
  2495.           SkipUntilIfEnd;
  2496.         end;
  2497.     else Next;
  2498.     end;
  2499. end;
  2500.  
  2501. procedure TmwDelphiDirectiveParser.SkipUntilElseIfOrIfEnd;
  2502. var
  2503.   Condition: Boolean;
  2504. begin
  2505.   Condition := False;
  2506.   while Id <> leAtEnd do
  2507.     case Id of
  2508.       leIfEnd, leElseIf,
  2509.       leElseDirective:
  2510.         begin
  2511.           if DirectiveStack.Count > 0 then
  2512.             case Integer(DirectiveStack.Peek) of
  2513.               leElseIf, leIfDirective: Condition := True;
  2514.             end;
  2515.           case Condition of
  2516.             True:
  2517.               begin
  2518.                 DirectiveStack.Pop;
  2519.                 if Id <> leIfEnd then
  2520.                   DirectiveStack.Push(TObject(Id));
  2521.                 FindDirectiveEnd;
  2522.                 Break;
  2523.               end;
  2524.             False:
  2525.               begin
  2526.                 if Assigned(fOnLexerError) then
  2527.                   fOnLexerError(Self, 'IfEnd/ElseIf without previous If or ElseIf directive');
  2528.               end;
  2529.           end;
  2530.         end;
  2531.       leIfDirective:
  2532.         begin
  2533.           DirectiveStack.Push(TObject(Id));
  2534.           FindDirectiveEnd;
  2535.           Next;
  2536.           SkipUntilIfEnd;
  2537.         end;
  2538.     else Next;
  2539.     end;
  2540. end;
  2541.  
  2542. procedure TmwDelphiDirectiveParser.SkipUntilElseOrEndIf;
  2543. var
  2544.   Condition: Boolean;
  2545. begin
  2546.   Condition := False;
  2547.   while Id <> leAtEnd do
  2548.     case Id of
  2549.       leElseDirective, leEndIf:
  2550.         begin
  2551.           if DirectiveStack.Count > 0 then
  2552.             case Integer(DirectiveStack.Peek) of
  2553.               leElseDirective, leIfDef, leIfNDef, leIfOpt: Condition := True;
  2554.             end;
  2555.           case Condition of
  2556.             True:
  2557.               begin
  2558.                 DirectiveStack.Pop;
  2559.                  if Id = leElseDirective then
  2560.                   DirectiveStack.Push(TObject(Integer(leElseDirective)));
  2561.                 FindDirectiveEnd;
  2562.                 Break;
  2563.               end;
  2564.             False:
  2565.               begin
  2566.                 if Assigned(fOnLexerError) then
  2567.                   fOnLexerError(Self, 'Else/EndIf without previous IfDef, Else, IfNDef or IfOpt directive');
  2568.               end;
  2569.           end;
  2570.         end;
  2571.       leIfDef, leIfNDef, leIfOpt:
  2572.         begin
  2573.           DirectiveStack.Push(TObject(Id));
  2574.           FindDirectiveEnd;
  2575.           Next;
  2576.           SkipUntilEndIf;
  2577.         end;
  2578.     else Next;
  2579.     end;
  2580. end;
  2581.  
  2582. end.
  2583.  
  2584.